// 选择功能模块
const tableSelection = {
  selectedCells: [],
  isSelecting: false,

  clearSelection() {
    this.selectedCells.forEach((cell) => {
      cell.classList.remove("selected");
    });
    this.selectedCells = [];
  },

  getCellStartColumn(cell) {
    const table = cell.closest('table');
    const currentRow = cell.parentElement;
    const rowIndex = currentRow.rowIndex;

    // 创建一个数组来跟踪每一列的占用情况
    const colSpans = new Array(1000).fill(0); // 使用足够大的数组

    // 检查当前行之前的所有行，处理跨行的单元格
    for (let i = 0; i < rowIndex; i++) {
      const row = table.rows[i];

      let colIndex = 0; // 包含合并单元格占据空间的（DOM中不可见单元格空间）列索引
      for (const td of row.cells) {
        // 跳过已被其他单元格占用的列
        while (colSpans[colIndex] > i) {
          colIndex++;
        }
        
        // 如果单元格跨行到当前行，更新占用情况 -- 找到离的最近的跨行单元格，并记录占用信息
        if (i + (td.rowSpan || 1) > rowIndex) {
          for (let j = 0; j < (td.colSpan || 1); j++) {
            // 该值用于判断某行的当前列是否在跨行单元格的范围内
            colSpans[colIndex + j] = i + (td.rowSpan || 1);
          }
        }
        colIndex += td.colSpan || 1;
      }
    }

    // 计算当前单元格的起始列
    let colIndex = 0;
    for (const td of currentRow.cells) {
      // 跳过被上方单元格占用的列 -- 该列包含在跨行单元格的范围内
      while (colSpans[colIndex] > rowIndex) {
        colIndex++;
      }
      
      if (td === cell) {
        return colIndex;
      }
      colIndex += td.colSpan || 1;
    }
    return colIndex;
  },

  handleMouseOver(e, table) {
    if (this.isSelecting && e.target.tagName === "TD") {
      e.preventDefault();
      const startCell = this.selectedCells[0];
      const currentCell = e.target;

      const startRow = Math.min(
        startCell.parentElement.rowIndex,
        currentCell.parentElement.rowIndex
      );
      const endRow = Math.max(
        startCell.parentElement.rowIndex + (startCell.rowSpan || 1) - 1,
        currentCell.parentElement.rowIndex + (currentCell.rowSpan || 1) - 1
      );
      // getCellStartColumn的计算并不准确，没有考虑列合并的情况
      const startCol = Math.min(
        this.getCellStartColumn(startCell),
        this.getCellStartColumn(currentCell)
      );
      const endCol = Math.max(
        this.getCellStartColumn(startCell) + (startCell.colSpan || 1) - 1,
        this.getCellStartColumn(currentCell) + (currentCell.colSpan || 1) - 1
      );
      console.log("startRow::", startRow, "startCol::", startCol);
      // endCol会算的不正确
      console.log("endRow::", endRow, "endCol::", endCol);
      // 范围区：
      // 鼠标划选时，矩形（由起点、终点确定）；

      // 解决思路：
      // 1. 创建矩形，以记录哪些单元格已经被选中
      // 2. 根据划选，确定选中范围
      // 3. 根据选中范围，更新矩形
      // 4. 根据矩形，确定哪些单元格被选中
      // 4.1 已经选中的记录在矩形中
      // 4.2 遍历遇到新的单元格，判断是否已经记录在矩形中，如果已经记录，则不记录，否则记录
      // 这样就提前锁定了合并单元格的范围，从而避免遍历到其它行时，合并格范围内的单元格被重复选中

      // 计算最大列数
      const data = tableData.getTableData(table);
      const maxCols = tableData.getMaxCols(data);

      // 创建一个二维数组来跟踪已被占用的位置
      const occupiedPositions = Array(data.length)
        .fill()
        .map(() => Array(maxCols).fill(false));

      this.clearSelection();

      for (let i = startRow; i <= endRow; i++) {
        const row = table.rows[i];
        if (!row) continue;

        for (let cell of row.cells) {
          const cellStartCol = this.getCellStartColumn(cell);
          const cellEndCol = cellStartCol + (cell.colSpan || 1) - 1;
          const cellStartRow = cell.parentElement.rowIndex;
          const cellEndRow = cellStartRow + (cell.rowSpan || 1) - 1;

          if (occupiedPositions[cellStartRow][cellStartCol]) continue;

          if (
            cellStartCol >= startCol &&
            cellEndCol <= endCol &&
            cellStartRow >= startRow &&
            cellEndRow <= endRow
          ) {
            this.selectedCells.push(cell);
            cell.classList.add("selected");
            for (let k = cellStartRow; k <= cellEndRow; k++) {
              for (let j = cellStartCol; j <= cellEndCol; j++) {
                occupiedPositions[k][j] = true;
              }
            }
          }
        }
      }
    }
  },
};
